package com.lwj.service.quartz;

import com.lwj.exception.BusinessException;
import com.lwj.model.quartz.JobInfo;
import com.lwj.model.quartz.NameValuePair;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.PostConstruct;
import java.util.*;
@Service
public class QuartzServiceImpl implements QuartzService{
    @Autowired
    private Scheduler scheduler;

    @PostConstruct
    public void startScheduler() {
        try {
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 增加一个job
     */
    @Override
    public void addJob(JobInfo jobInfo) {
        try {
            // 先验证cron表达式是否正确，防止添加完job后trigger添加异常导致又得删除job
            // 任务名称和组构成任务key
            JobDetail jobDetail = JobBuilder.newJob((Class<? extends QuartzJobBean>) Class.forName(jobInfo.getJobClass())).withIdentity(jobInfo.getJobName(), jobInfo.getJobGroup()).build();
            // 设置job参数
            List<NameValuePair> params = jobInfo.getParams();
            if (!CollectionUtils.isEmpty(params)) {
                params.stream().forEach(item->{
                    jobDetail.getJobDataMap().put(item.getKey(),item.getValue());
                });
            }
            SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.repeatSecondlyForever(1).withIntervalInSeconds(jobInfo.getJobGap());
            if(jobInfo.getJobCount() < 0){
                scheduleBuilder.withRepeatCount(jobInfo.getJobCount());
            }
            // 使用simpleTrigger规则
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobInfo.getJobName(), jobInfo.getJobGroup()).withSchedule(scheduleBuilder).startNow().build();
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (Exception e) {
             throw new BusinessException();
        }
    }

    /**
     * 增加一个job
     *  *    *     *     *    *     *   *
     * [秒] [分] [小时]  [日]  [月]  [周] [年]
     *        是否必填      允许填写的值        允许的通配符
     * 秒：    是           0-59              , - * /
     *
     * 分：    是           0-59              , - * /
     *
     * 小时：  是           0-23              , - * /
     *
     *  日    是           1-31              , - * ? / L W
     *
     *  月    是          1-12 or JAN-DEC    , - * /
     *
     *  周    是          1-7 or SUN-SAT     , - * ? / L #
     *
     *  年    否          empty 或 1970-2099  , - * /
     *
     *  通配符说明:
     * * 表示所有值. 例如:在分的字段上设置 "*",表示每一分钟都会触发。
     * ? 表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0 10 * ?
     * - 表示区间。例如 在小时上设置 "10-12",表示 10,11,12点都会触发。
     * , 表示指定多个值，例如在周字段上设置 "MON,WED,FRI" 表示周一，周三和周五触发
     * / 用于递增触发。如在秒上面设置"5/15" 表示从5秒开始，每增15秒触发(5,20,35,50)。在月字段上设置'1/3'所示每月1号开始，每隔三天触发一次。
     * L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于"7"或"SAT"。如果在"L"前加上数字，则表示该数据的最后一个。例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五"
     * W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W"，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 "1W",它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，"W"前只能设置具体的数字,不允许区间"-").
     * 小提示
     * 'L'和 'W'可以一组合使用。如果在日字段上设置"LW",则表示在本月的最后一个工作日触发(一般指发工资 )
     * # 序号(表示每月的第几个周几)，例如在周字段上设置"6#3"表示在每月的第三个周六.注意如果指定"#5",正好第五周没有周六，则不会触发该配置(用在母亲节和父亲节再合适不过了)
     * 小提示
     * 周字段的设置，若使用英文字母是不区分大小写的 MON 与mon相同.
     */
    @Override
    public void addJobByTime(JobInfo jobInfo) {
        try {
            // 创建jobDetail实例，绑定Job实现类
            // 指明job的名称，所在组的名称，以及绑定job类
            // 任务名称和组构成任务key
            // 先验证cron表达式是否正确，防止添加完job后trigger添加异常导致又得删除job
            CronExpression.validateExpression(jobInfo.getJobTime());
            JobDetail jobDetail = JobBuilder.newJob((Class<? extends QuartzJobBean>) Class.forName(jobInfo.getJobClass())).storeDurably().withIdentity(jobInfo.getJobName(), jobInfo.getJobGroup())
                    .build();
            // 设置job参数
            List<NameValuePair> params = jobInfo.getParams();
            if (!CollectionUtils.isEmpty(params)) {
                params.stream().forEach(item->{
                    jobDetail.getJobDataMap().put(item.getKey(),item.getValue());
                });
            }
            // 定义调度触发规则
            // 使用cornTrigger规则
            // 触发器key
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobInfo.getJobName(), jobInfo.getJobGroup())
                    .startAt(DateBuilder.futureDate(1, DateBuilder.IntervalUnit.SECOND))
                    .withSchedule(CronScheduleBuilder.cronSchedule(jobInfo.getJobTime())).startNow().build();
            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (Exception e) {
            throw new BusinessException();
        }
    }

    /**
     * 修改 一个job的 时间表达式
     *
     * @param jobName
     * @param jobGroupName
     * @param jobTime
     */
    @Override
    public void updateJob(String jobName, String jobGroupName, String jobTime) {
        try {
            // 先验证cron表达式是否正确，防止添加完job后trigger添加异常导致又得删除job
            CronExpression.validateExpression(jobTime);
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                    .withSchedule(CronScheduleBuilder.cronSchedule(jobTime)).build();
            // 重启触发器
            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (Exception e) {
             throw new BusinessException();
        }
    }

    /**
     * 删除任务一个job
     *
     * @param jobName      任务名称
     * @param jobGroupName 任务组名
     */
    @Override
    public void deleteJob(String jobName, String jobGroupName) {
        try {
            scheduler.deleteJob(new JobKey(jobName, jobGroupName));
        } catch (Exception e) {
             throw new BusinessException();
        }
    }

    /**
     * 暂停一个job
     *
     * @param jobName
     * @param jobGroupName
     */
    @Override
    public void pauseJob(String jobName, String jobGroupName) {
        try {
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
            scheduler.pauseJob(jobKey);
        } catch (SchedulerException e) {
             throw new BusinessException();
        }
    }

    /**
     * 恢复一个job
     *
     * @param jobName
     * @param jobGroupName
     */
    @Override
    public void resumeJob(String jobName, String jobGroupName) {
        try {
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
             throw new BusinessException();
        }
    }

    /**
     * 立即执行一个job
     *
     * @param jobName
     * @param jobGroupName
     */
    @Override
    public void runAJobNow(String jobName, String jobGroupName) {
        try {
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
            scheduler.triggerJob(jobKey);
        } catch (SchedulerException e) {
             throw new BusinessException();
        }
    }

    /**
     * 获取所有计划中的任务列表
     *
     * @return
     */
    @Override
    public List<JobInfo> queryAllJob() {
        List<JobInfo> jobList = null;
        try {
            GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
            Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
            jobList = new ArrayList<>();
            for (JobKey jobKey : jobKeys) {
                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggers) {
                    JobInfo job = new JobInfo();
                    job.setJobName(jobKey.getName());
                    job.setJobGroup(jobKey.getGroup());
                    Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                    job.setRunning(triggerState != Trigger.TriggerState.PAUSED);
                    if (trigger instanceof CronTrigger) {
                        CronTrigger cronTrigger = (CronTrigger) trigger;
                        String cronExpression = cronTrigger.getCronExpression();
                        job.setJobTime(cronExpression);
                    }
                    JobDetail jd = scheduler.getJobDetail(jobKey);
                    job.setJobClass(jd.getJobClass().getName());
                    List<NameValuePair> params = new ArrayList<>();
                    for (String x : jd.getJobDataMap().keySet()) {
                        NameValuePair pair = new NameValuePair();
                        pair.setKey(x);
                        pair.setValue(jd.getJobDataMap().getString(x));
                        params.add(pair);
                    }
                    job.setParams(params);
                    jobList.add(job);
                }
            }
        } catch (SchedulerException e) {
             throw new BusinessException();
        }
        return jobList;
    }

    /**
     * 获取所有正在运行的job
     *
     * @return
     */
    @Override
    public List<JobInfo> queryRunJob() {
        List<JobInfo> jobList = null;
        try {
            List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
            jobList = new ArrayList<>();
            for (JobExecutionContext executingJob : executingJobs) {
                Map<String, Object> map = new HashMap<String, Object>();
                JobDetail jobDetail = executingJob.getJobDetail();
                JobKey jobKey = jobDetail.getKey();
                Trigger trigger = executingJob.getTrigger();
                JobInfo job = new JobInfo();
                job.setJobClass(jobKey.getClass().getName());
                job.setJobName(jobKey.getName());
                job.setJobGroup(jobKey.getGroup());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                job.setRunning(triggerState != Trigger.TriggerState.PAUSED);
                if (trigger instanceof CronTrigger) {
                    CronTrigger cronTrigger = (CronTrigger) trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    job.setJobTime(cronExpression);
                }
                JobDetail jd = scheduler.getJobDetail(jobKey);
                List<NameValuePair> params = new ArrayList<>();
                for (String x : jd.getJobDataMap().keySet()) {
                    NameValuePair pair = new NameValuePair();
                    pair.setKey(x);
                    pair.setValue(jd.getJobDataMap().getString(x));
                    params.add(pair);
                }
                job.setParams(params);
                jobList.add(job);
            }
        } catch (SchedulerException e) {
             throw new BusinessException();
        }
        return jobList;
    }
}

